# -*- coding: utf-8 -*-
import mathfrom mod.client import extraClientApidef fromTuple(data):
    # type: (tuple) -> Vector
    """
    从元组中解析向量
    支持传入以下格式：
    (x,y)
    (x,y,z)

    参数：
        s (str)：向量字符串

    返回：
        vector (Vector)：解析得到的向量
    """
    pass

def fromStr(s):
    # type: (str or tuple) -> Vector
    """
    从元组或字符串中解析向量
    支持传入以下格式：
    (x,y)
    (x,y,z)
    “x,y”
    “x,y,z”
    “x,y,z,维度”

    参数：
        s (str)：向量字符串

    返回：
        vector (Vector)：解析得到的向量
    """
    pass

class Vector(object):
    def __init__(self, x, y, z):
        """
        三维向量类，用于表示三维空间中的坐标或方向。

        参数：
            x (float)：向量在X轴上的坐标。
            y (float)：向量在Y轴上的坐标。
            z (float)：向量在Z轴上的坐标。
            dimension (int)：向量所在维度的标识，默认为None。

        属性：
            x (float)：向量在X轴上的坐标。
            y (float)：向量在Y轴上的坐标。
            z (float)：向量在Z轴上的坐标。
            dimension (int)：向量所在维度的标识。
        """
        self.x = 0.0  # type: float
        self.y = 0.0  # type: float
        self.z = 0.0  # type: float
        self.dimension = 0  # type: int
        pass

    def getLocation(self):
        # type: () -> None
        """
        返回它自己。主要是为了和Creature混用
        返回：
            返回向量自己。
        """
        pass

    def __repr__(self):
        # type: (无参数。) -> None
        """
        返回向量的字符串表示。

        参数：
            无参数。

        返回：
            返回向量的字符串表示，格式为"x,y,z"。
        """
        pass

    def __str__(self):
        # type: (无参数。) -> None
        """
        返回向量的字符串表示。

        参数：
            无参数。

        返回：
            返回向量的字符串表示，格式为"x,y,z"。
        """
        pass

    def __getitem__(self, key):
        # type: (int) -> None
        """
        获取向量的指定索引处的分量值。

        参数：
            key (int)：分量的索引，取值范围为0到2。

        返回：
            返回指定索引处的分量值。
        """
        pass

    def add(self, vec):
        # type: (Vector) -> Vector
        """
        将当前向量与给定向量相加，返回结果向量。

        参数：
            vec (Vector)：待相加的向量。

        返回：
            返回将给定向量与当前向量相加的结果向量。
        """
        pass

    def offset(self, x, y, z):
        # type: (float, float, float) -> Vector
        """
        将当前向量沿指定方向偏移给定距离，并返回结果向量。

        参数：
            x (float)：X轴方向的偏移量。
            y (float)：Y轴方向的偏移量。
            z (float)：Z轴方向的偏移量。

        返回：
            返回沿指定方向偏移给定距离后的向量。
        """
        pass

    def toReadable(self):
        # type: (无参数。) -> None
        """
        返回可读性较好的向量字符串表示。

        参数：
            无参数。

        返回：
            返回可读性较好的向量字符串表示，格式为"x, y, z"。
        """
        pass

    def sum(self):
        # type: (无参数。) -> None
        """
        计算向量各分量的和。

        参数：
            无参数。

        返回：
            返回向量各分量的和。
        """
        pass

    def subtract(self, vec):
        # type: (Vector) -> Vector
        """
        将当前向量与给定向量相减，返回结果向量。

        参数：
            vec (Vector)：待相减的向量。

        返回：
            返回将给定向量从当前向量中减去的结果向量。
        """
        pass

    def times(self, vec):
        # type: (Vector) -> Vector
        """
        将当前向量与给定向量按元素相乘，或将当前向量与给定数值相乘，返回结果向量。

        参数：
            vec (Vector or float)：如果是向量，则按元素相乘；如果是数值，则将当前向量的各分量与该数值相乘。

        返回：
            返回按要求相乘后的结果向量。
        """
        pass

    def divide(self, vec):
        # type: (Vector) -> Vector
        """
        将当前向量与给定向量按元素相除，或将当前向量与给定数值相除，返回结果向量。

        参数：
            vec (Vector or float)：如果是向量，则按元素相除；如果是数值，则将当前向量的各分量与该数值相除。

        返回：
            返回按要求相除后的结果向量。
        """
        pass

    def length(self):
        # type: () -> float
        """
        计算向量的长度。

        参数：
            无参数。

        返回：
            返回向量的长度。
        """
        pass

    def lengthSquared(self):
        # type: () -> float
        """
        计算向量的长度的平方。

        参数：
            无参数。

        返回：
            返回向量的长度的平方。
        """
        pass

    def distance(self, vec):
        # type: (Vector) -> float
        """
        计算当前向量与给定向量之间的距离。若要比较长度建议用distanceSquared，更省性能

        参数：
            vec (Vector)：待计算距离的向量。

        返回：
            返回当前向量与给定向量之间的距离。
        """
        pass

    def getRot(self):
        # type: (无参数。) -> None
        """
        根据向量表示的朝向获取旋转值。

        参数：
            无参数。

        返回：
            返回根据向量表示的朝向计算得到的旋转值。
        """
        pass

    def __sub__(self, other):
        # type: (Vector) -> None
        """
        重载减法运算符，将当前向量减去给定向量，返回结果向量。

        参数：
            other (Vector)：待相减的向量。

        返回：
            返回将给定向量从当前向量中减去的结果向量。
        """
        pass

    def __abs__(self):
        # type: (无参数。) -> None
        """
        返回各分量取绝对值后的向量。

        参数：
            无参数。

        返回：
            返回各分量取绝对值后的向量。
        """
        pass

    def __add__(self, other):
        # type: (Vector) -> None
        """
        重载加法运算符，将当前向量加上给定向量，返回结果向量。

        参数：
            other (Vector)：待相加的向量。

        返回：
            返回将给定向量与当前向量相加的结果向量。
        """
        pass

    def distanceSquared(self, vec):
        # type: (Vector) -> float
        """
        计算当前向量与给定向量之间的距离的平方。（在比较长度时建议用这个，较省性能）

        参数：
            vec (Vector)：待计算距离的向量。

        返回：
            返回当前向量与给定向量之间的距离的平方。
        """
        pass

    def dot(self, vec):
        # type: (Vector) -> float
        """
        计算当前向量与给定向量的点积。

        参数：
            vec (Vector)：待计算点积的向量。

        返回：
            返回当前向量与给定向量的点积。
        """
        pass

    def angle(self, vec):
        # type: (Vector) -> float
        """
        计算当前向量与给定向量之间的夹角。

        参数：
            vec (Vector)：待计算夹角的向量。

        返回：
            返回当前向量与给定向量之间的夹角。
        """
        pass

    def copy(self, vec):
        # type: (Vector) -> Vector
        """
        将给定向量的值复制到当前向量，返回当前向量。

        参数：
            vec (Vector)：待复制的向量。

        返回：
            返回更新后的当前向量。
        """
        pass

    def midpoint(self, vec):
        # type: (Vector) -> Vector
        """
        计算当前向量与给定向量之间的中点。

        参数：
            vec (Vector)：待计算中点的向量。

        返回：
            返回当前向量与给定向量之间的中点。
        """
        pass

    def toFloatList(self):
        # type: () -> list[float]
        """
        将向量转化为浮点数列表

        Returns:
            list[float]: 浮点数列表，[x, y, z]
        """
        pass

    def toFloatTuple(self):
        # type: () -> x, y, z
        """
        将向量转化为浮点数元组

        Returns:
            tuple[float]: 浮点数元组，(x, y, z)
        """
        pass

    def toUID(self):
        # type: () -> int
        """
        将向量转化为唯一标识符，用于快速查找相同向量

        Returns:
            int: 唯一标识符
        """
        pass

    def toIntTuple(self):
        # type: () -> int(x
        """
        将向量转化为整数元组

        Returns:
            tuple[int]: 整数元组，(int(x), int(y), int(z))
        """
        pass

    def multiply(self, m):
        # type: (float) -> Vector
        """
        向量数乘，返回新的向量实例

        Args:
            m (float): 数乘因子

        Returns:
            Vector: 新的向量实例，self * m
        """
        pass

    def crossproduct(self, o):
        # type: (Vector) -> Vector
        """
        向量叉乘，返回新的向量实例

        Args:
            o (Vector): 另一个向量实例

        Returns:
            Vector: 新的向量实例，self x o
        """
        pass

    def normalize(self):
        # type: () -> Vector
        """
        归一化向量，返回新的向量实例

        Args:
            length (float, optional): 向量长度，默认为None，若为None则自动计算

        Returns:
            Vector: 归一化后的新向量实例
        """
        pass

    def __eq__(self, other):
        # type: (Vector or tuple[float]) -> bool
        """
        判断两个向量是否相等

        Args:
            other (Vector or tuple[float]): 另一个向量实例或元组

        Returns:
            bool: True表示相等，False表示不相等
        """
        pass

    def __div__(self, other):
        # type: (float) -> Vector
        """
        向量除法，返回新的向量实例

        Args:
            other (float): 除数

        Returns:
            Vector: 新的向量实例，self / other
        """
        pass

    def __mul__(self, other):
        # type: (Vector or float) -> Vector
        """
        向量乘法，返回新的向量实例

        Args:
            other (Vector or float): 乘数，可以是另一个向量实例或数值

        Returns:
            Vector: 新的向量实例，self * other
        """
        pass

    def addLaunchOffset(self, launchOffset, direction, angleOffset):
        # type: (list[float], Vector, float) -> Vector
        """
        根据传入的方向，向（前，上，右）方向偏移，返回新的向量实例

        Args:
            launchOffset (list[float]): 发射偏移量，分别是 向前 向上 向右
            direction (Vector): 瞄准方位向量
            angleOffset (float): 瞄准方向顺时针旋转

        Returns:
            Vector: 添加发射偏移量后的新向量实例
        """
        pass

    def getYaw(self):
        # type: (无参数。) -> None
        """
        获取向量的水平方向角度。

        参数：
            无参数。

        返回：
            返回向量的水平方向角度。
        """
        pass

    def clone(self):
        # type: () -> Vector
        """
        复制向量实例，返回新的向量实例

        Returns:
            Vector: 新的向量实例，与原向量实例相同
        """
        pass

    def rotateAroundZ(self, degrees):
        # type: (float) -> Vector
        """
        将向量围绕z轴旋转指定角度，返回新的向量实例

        Args:
            degrees (float): 旋转角度

        Returns:
            Vector: 旋转后的新向量实例
        """
        pass

    def rotateAroundX(self, degrees):
        # type: (float) -> Vector
        """
        将向量围绕x轴旋转指定角度，返回新的向量实例

        Args:
            degrees (float): 旋转角度

        Returns:
            Vector: 旋转后的新向量实例
        """
        pass

    def rotateAroundY(self, degrees):
        # type: (float) -> Vector
        """
        将向量围绕y轴旋转指定角度，返回新的向量实例

        Args:
            degrees (float): 旋转角度

        Returns:
            Vector: 旋转后的新向量实例
        """
        pass

    def _getIntermediateWithXValue(self, vec, x):
        # type: (Vector, float) -> Vector or None
        """
        在x轴上给定一个值x，返回当前向量与另一个向量vec之间的插值点。

        Args:
            vec (Vector): 另一个向量。
            x (float): 给定的x值。

        Returns:
            Vector or None: 插值点的Vector实例，如果插值不可行则返回None。
        """
        pass

    def _getIntermediateWithYValue(self, vec, y):
        # type: (Vector, float) -> Vector or None
        """
        在y轴上给定一个值y，返回当前向量与另一个向量vec之间的插值点。

        Args:
            vec (Vector): 另一个向量。
            y (float): 给定的y值。

        Returns:
            Vector or None: 插值点的Vector实例，如果插值不可行则返回None。
        """
        pass

    def _getIntermediateWithZValue(self, vec, z):
        # type: (Vector, float) -> Vector or None
        """
        在z轴上给定一个值z，返回当前向量与另一个向量vec之间的插值点。

        Args:
            vec (Vector): 另一个向量。
            z (float): 给定的z值。

        Returns:
            Vector or None: 插值点的Vector实例，如果插值不可行则返回None。
        """
        pass

    def getBlock(self):
        # type: () -> None
        """
        Returns:
            None: 客户端无法使用
        """
        pass

    def isChunkLoaded(self):
        # type: () -> None
        """
        Returns:
            None: 客户端无法使用
        """
        pass

    def isZero(self):
        # type: () -> bool
        """
        判断当前向量是否为零向量。

        Returns:
            bool: 当前向量是否为零向量。
        """
        pass

